home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / util / gnu / fileutils_3_3.lha / fileutils-3.3 / lib / posixtm.c < prev    next >
C/C++ Source or Header  |  1992-08-02  |  21KB  |  898 lines
  1.  
  2. /*  A Bison parser, made from posixtm.y  */
  3.  
  4. #define    DIGIT    258
  5.  
  6. #line 19 "posixtm.y"
  7.  
  8. #ifdef __GNUC__
  9. #define alloca __builtin_alloca
  10. #else
  11. #ifdef sparc
  12. #include <alloca.h>
  13. #else
  14. #ifdef _AIX
  15.  #pragma alloca
  16. #else
  17. char *alloca ();
  18. #endif
  19. #endif
  20. #endif
  21.  
  22. #include <stdio.h>
  23. #include <sys/types.h>
  24. #include <time.h>
  25.  
  26. #define YYDEBUG 1
  27.  
  28. /* Lexical analyzer's current scan position in the input string. */
  29. static char *curpos;
  30.  
  31. /* The return value. */
  32. static struct tm t;
  33.  
  34. time_t mktime ();
  35.  
  36. #define zzparse posixtime_zzparse
  37. static int zzlex ();
  38. static int zzerror ();
  39.  
  40. #ifndef YYLTYPE
  41. typedef
  42.   struct zzltype
  43.     {
  44.       int timestamp;
  45.       int first_line;
  46.       int first_column;
  47.       int last_line;
  48.       int last_column;
  49.       char *text;
  50.    }
  51.   zzltype;
  52.  
  53. #define YYLTYPE zzltype
  54. #endif
  55.  
  56. #ifndef YYSTYPE
  57. #define YYSTYPE int
  58. #endif
  59. #include <stdio.h>
  60.  
  61. #ifndef __STDC__
  62. #define const
  63. #endif
  64.  
  65.  
  66.  
  67. #define    YYFINAL        15
  68. #define    YYFLAG        -32768
  69. #define    YYNTBASE    5
  70.  
  71. #define YYTRANSLATE(x) ((unsigned)(x) <= 258 ? zztranslate[x] : 9)
  72.  
  73. static const char zztranslate[] = {     0,
  74.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  75.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  76.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  77.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  78.      2,     2,     2,     2,     2,     4,     2,     2,     2,     2,
  79.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  80.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  81.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  82.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  83.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  84.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  85.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  86.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  87.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  88.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  89.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  90.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  91.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  92.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  93.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  94.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  95.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  96.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  97.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  98.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  99.      2,     2,     2,     2,     2,     1,     2,     3
  100. };
  101.  
  102. static const short zzprhs[] = {     0,
  103.      0,     7,     9,    12,    13,    14,    17
  104. };
  105.  
  106. static const short zzrhs[] = {     8,
  107.      8,     8,     8,     6,     7,     0,     8,     0,     8,     8,
  108.      0,     0,     0,     4,     8,     0,     3,     3,     0
  109. };
  110.  
  111. #if YYDEBUG != 0
  112. static const short zzrline[] = { 0,
  113.     56,    85,    92,    99,   110,   113,   122
  114. };
  115.  
  116. static const char * const zztname[] = {   "$",
  117. "error","$illegal.","DIGIT","'.'","date","year","seconds","digitpair",""
  118. };
  119. #endif
  120.  
  121. static const short zzr1[] = {     0,
  122.      5,     6,     6,     6,     7,     7,     8
  123. };
  124.  
  125. static const short zzr2[] = {     0,
  126.      6,     1,     2,     0,     0,     2,     2
  127. };
  128.  
  129. static const short zzdefact[] = {     0,
  130.      0,     0,     7,     0,     0,     4,     5,     2,     0,     1,
  131.      3,     6,     0,     0,     0
  132. };
  133.  
  134. static const short zzdefgoto[] = {    13,
  135.      7,    10,     2
  136. };
  137.  
  138. static const short zzpact[] = {     2,
  139.      5,     2,-32768,     2,     2,     2,-    3,     2,     2,-32768,
  140. -32768,-32768,     9,    10,-32768
  141. };
  142.  
  143. static const short zzpgoto[] = {-32768,
  144. -32768,-32768,-    2
  145. };
  146.  
  147.  
  148. #define    YYLAST        10
  149.  
  150.  
  151. static const short zztable[] = {     4,
  152.      9,     5,     6,     8,     1,    11,    12,     3,    14,    15
  153. };
  154.  
  155. static const short zzcheck[] = {     2,
  156.      4,     4,     5,     6,     3,     8,     9,     3,     0,     0
  157. };
  158. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  159. #line 3 "bison.simple"
  160.  
  161. /* Skeleton output parser for bison,
  162.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  163.  
  164.    This program is free software; you can redistribute it and/or modify
  165.    it under the terms of the GNU General Public License as published by
  166.    the Free Software Foundation; either version 1, or (at your option)
  167.    any later version.
  168.  
  169.    This program is distributed in the hope that it will be useful,
  170.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  171.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  172.    GNU General Public License for more details.
  173.  
  174.    You should have received a copy of the GNU General Public License
  175.    along with this program; if not, write to the Free Software
  176.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  177.  
  178.  
  179. #ifndef alloca
  180. #ifdef __GNUC__
  181. #define alloca __builtin_alloca
  182. #else /* Not GNU C.  */
  183. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  184. #include <alloca.h>
  185. #else /* Not sparc */
  186. #ifdef MSDOS
  187. #include <malloc.h>
  188. #endif /* MSDOS */
  189. #endif /* Not sparc.  */
  190. #endif /* Not GNU C.  */
  191. #endif /* alloca not defined.  */
  192.  
  193. /* This is the parser code that is written into each bison parser
  194.   when the %semantic_parser declaration is not specified in the grammar.
  195.   It was written by Richard Stallman by simplifying the hairy parser
  196.   used when %semantic_parser is specified.  */
  197.  
  198. /* Note: there must be only one dollar sign in this file.
  199.    It is replaced by the list of actions, each action
  200.    as one case of the switch.  */
  201.  
  202. #define zzerrok        (zzerrstatus = 0)
  203. #define zzclearin    (zzchar = YYEMPTY)
  204. #define YYEMPTY        -2
  205. #define YYEOF        0
  206. #define YYACCEPT    return(0)
  207. #define YYABORT     return(1)
  208. #define YYERROR        goto zzerrlab1
  209. /* Like YYERROR except do call zzerror.
  210.    This remains here temporarily to ease the
  211.    transition to the new meaning of YYERROR, for GCC.
  212.    Once GCC version 2 has supplanted version 1, this can go.  */
  213. #define YYFAIL        goto zzerrlab
  214. #define YYRECOVERING()  (!!zzerrstatus)
  215. #define YYBACKUP(token, value) \
  216. do                                \
  217.   if (zzchar == YYEMPTY && zzlen == 1)                \
  218.     { zzchar = (token), zzlval = (value);            \
  219.       zzchar1 = YYTRANSLATE (zzchar);                \
  220.       YYPOPSTACK;                        \
  221.       goto zzbackup;                        \
  222.     }                                \
  223.   else                                \
  224.     { zzerror ("syntax error: cannot back up"); YYERROR; }    \
  225. while (0)
  226.  
  227. #define YYTERROR    1
  228. #define YYERRCODE    256
  229.  
  230. #ifndef YYPURE
  231. #define YYLEX        zzlex()
  232. #endif
  233.  
  234. #ifdef YYPURE
  235. #ifdef YYLSP_NEEDED
  236. #define YYLEX        zzlex(&zzlval, &zzlloc)
  237. #else
  238. #define YYLEX        zzlex(&zzlval)
  239. #endif
  240. #endif
  241.  
  242. /* If nonreentrant, generate the variables here */
  243.  
  244. #ifndef YYPURE
  245.  
  246. int    zzchar;            /*  the lookahead symbol        */
  247. YYSTYPE    zzlval;            /*  the semantic value of the        */
  248.                 /*  lookahead symbol            */
  249.  
  250. #ifdef YYLSP_NEEDED
  251. YYLTYPE zzlloc;            /*  location data for the lookahead    */
  252.                 /*  symbol                */
  253. #endif
  254.  
  255. int zznerrs;            /*  number of parse errors so far       */
  256. #endif  /* not YYPURE */
  257.  
  258. #if YYDEBUG != 0
  259. int zzdebug;            /*  nonzero means print parse trace    */
  260. /* Since this is uninitialized, it does not stop multiple parsers
  261.    from coexisting.  */
  262. #endif
  263.  
  264. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  265.  
  266. #ifndef    YYINITDEPTH
  267. #define YYINITDEPTH 200
  268. #endif
  269.  
  270. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  271.     (effective only if the built-in stack extension method is used).  */
  272.  
  273. #if YYMAXDEPTH == 0
  274. #undef YYMAXDEPTH
  275. #endif
  276.  
  277. #ifndef YYMAXDEPTH
  278. #define YYMAXDEPTH 10000
  279. #endif
  280.  
  281. #ifndef __cplusplus
  282.  
  283. /* This is the most reliable way to avoid incompatibilities
  284.    in available built-in functions on various systems.  */
  285. static void
  286. __zz_bcopy (from, to, count)
  287.      char *from;
  288.      char *to;
  289.      int count;
  290. {
  291.   register char *f = from;
  292.   register char *t = to;
  293.   register int i = count;
  294.  
  295.   while (i-- > 0)
  296.     *t++ = *f++;
  297. }
  298.  
  299. #else /* __cplusplus */
  300.  
  301. /* This is the most reliable way to avoid incompatibilities
  302.    in available built-in functions on various systems.  */
  303. static void
  304. __zz_bcopy (char *from, char *to, int count)
  305. {
  306.   register char *f = from;
  307.   register char *t = to;
  308.   register int i = count;
  309.  
  310.   while (i-- > 0)
  311.     *t++ = *f++;
  312. }
  313.  
  314. #endif
  315.  
  316. #line 160 "bison.simple"
  317. int
  318. zzparse()
  319. {
  320.   register int zzstate;
  321.   register int zzn;
  322.   register short *zzssp;
  323.   register YYSTYPE *zzvsp;
  324.   int zzerrstatus;    /*  number of tokens to shift before error messages enabled */
  325.   int zzchar1;        /*  lookahead token as an internal (translated) token number */
  326.  
  327.   short    zzssa[YYINITDEPTH];    /*  the state stack            */
  328.   YYSTYPE zzvsa[YYINITDEPTH];    /*  the semantic value stack        */
  329.  
  330.   short *zzss = zzssa;        /*  refer to the stacks thru separate pointers */
  331.   YYSTYPE *zzvs = zzvsa;    /*  to allow zzoverflow to reallocate them elsewhere */
  332.  
  333. #ifdef YYLSP_NEEDED
  334.   YYLTYPE *zzls = zzlsa;
  335.   YYLTYPE *zzlsp;
  336.   YYLTYPE zzlsa[YYINITDEPTH];    /*  the location stack            */
  337.  
  338. #define YYPOPSTACK   (zzvsp--, zzsp--, zzlsp--)
  339. #else
  340. #define YYPOPSTACK   (zzvsp--, zzsp--)
  341. #endif
  342.  
  343.   int zzstacksize = YYINITDEPTH;
  344.  
  345. #ifdef YYPURE
  346.   int zzchar;
  347.   YYSTYPE zzlval;
  348.   int zznerrs;
  349. #ifdef YYLSP_NEEDED
  350.   YYLTYPE zzlloc;
  351. #endif
  352. #endif
  353.  
  354.   YYSTYPE zzval;        /*  the variable used to return        */
  355.                 /*  semantic values from the action    */
  356.                 /*  routines                */
  357.  
  358.   int zzlen;
  359.  
  360. #if YYDEBUG != 0
  361.   if (zzdebug)
  362.     fprintf(stderr, "Starting parse\n");
  363. #endif
  364.  
  365.   zzstate = 0;
  366.   zzerrstatus = 0;
  367.   zznerrs = 0;
  368.   zzchar = YYEMPTY;        /* Cause a token to be read.  */
  369.  
  370.   /* Initialize stack pointers.
  371.      Waste one element of value and location stack
  372.      so that they stay on the same level as the state stack.  */
  373.  
  374.   zzssp = zzss - 1;
  375.   zzvsp = zzvs;
  376. #ifdef YYLSP_NEEDED
  377.   zzlsp = zzls;
  378. #endif
  379.  
  380. /* Push a new state, which is found in  zzstate  .  */
  381. /* In all cases, when you get here, the value and location stacks
  382.    have just been pushed. so pushing a state here evens the stacks.  */
  383. zznewstate:
  384.  
  385.   *++zzssp = zzstate;
  386.  
  387.   if (zzssp >= zzss + zzstacksize - 1)
  388.     {
  389.       /* Give user a chance to reallocate the stack */
  390.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  391.       YYSTYPE *zzvs1 = zzvs;
  392.       short *zzss1 = zzss;
  393. #ifdef YYLSP_NEEDED
  394.       YYLTYPE *zzls1 = zzls;
  395. #endif
  396.  
  397.       /* Get the current used size of the three stacks, in elements.  */
  398.       int size = zzssp - zzss + 1;
  399.  
  400. #ifdef zzoverflow
  401.       /* Each stack pointer address is followed by the size of
  402.      the data in use in that stack, in bytes.  */
  403.       zzoverflow("parser stack overflow",
  404.          &zzss1, size * sizeof (*zzssp),
  405.          &zzvs1, size * sizeof (*zzvsp),
  406. #ifdef YYLSP_NEEDED
  407.          &zzls1, size * sizeof (*zzlsp),
  408. #endif
  409.          &zzstacksize);
  410.  
  411.       zzss = zzss1; zzvs = zzvs1;
  412. #ifdef YYLSP_NEEDED
  413.       zzls = zzls1;
  414. #endif
  415. #else /* no zzoverflow */
  416.       /* Extend the stack our own way.  */
  417.       if (zzstacksize >= YYMAXDEPTH)
  418.     {
  419.       zzerror("parser stack overflow");
  420.       return 2;
  421.     }
  422.       zzstacksize *= 2;
  423.       if (zzstacksize > YYMAXDEPTH)
  424.     zzstacksize = YYMAXDEPTH;
  425.       zzss = (short *) alloca (zzstacksize * sizeof (*zzssp));
  426.       __zz_bcopy ((char *)zzss1, (char *)zzss, size * sizeof (*zzssp));
  427.       zzvs = (YYSTYPE *) alloca (zzstacksize * sizeof (*zzvsp));
  428.       __zz_bcopy ((char *)zzvs1, (char *)zzvs, size * sizeof (*zzvsp));
  429. #ifdef YYLSP_NEEDED
  430.       zzls = (YYLTYPE *) alloca (zzstacksize * sizeof (*zzlsp));
  431.       __zz_bcopy ((char *)zzls1, (char *)zzls, size * sizeof (*zzlsp));
  432. #endif
  433. #endif /* no zzoverflow */
  434.  
  435.       zzssp = zzss + size - 1;
  436.       zzvsp = zzvs + size - 1;
  437. #ifdef YYLSP_NEEDED
  438.       zzlsp = zzls + size - 1;
  439. #endif
  440.  
  441. #if YYDEBUG != 0
  442.       if (zzdebug)
  443.     fprintf(stderr, "Stack size increased to %d\n", zzstacksize);
  444. #endif
  445.  
  446.       if (zzssp >= zzss + zzstacksize - 1)
  447.     YYABORT;
  448.     }
  449.  
  450. #if YYDEBUG != 0
  451.   if (zzdebug)
  452.     fprintf(stderr, "Entering state %d\n", zzstate);
  453. #endif
  454.  
  455.  zzbackup:
  456.  
  457. /* Do appropriate processing given the current state.  */
  458. /* Read a lookahead token if we need one and don't already have one.  */
  459. /* zzresume: */
  460.  
  461.   /* First try to decide what to do without reference to lookahead token.  */
  462.  
  463.   zzn = zzpact[zzstate];
  464.   if (zzn == YYFLAG)
  465.     goto zzdefault;
  466.  
  467.   /* Not known => get a lookahead token if don't already have one.  */
  468.  
  469.   /* zzchar is either YYEMPTY or YYEOF
  470.      or a valid token in external form.  */
  471.  
  472.   if (zzchar == YYEMPTY)
  473.     {
  474. #if YYDEBUG != 0
  475.       if (zzdebug)
  476.     fprintf(stderr, "Reading a token: ");
  477. #endif
  478.       zzchar = YYLEX;
  479.     }
  480.  
  481.   /* Convert token to internal form (in zzchar1) for indexing tables with */
  482.  
  483.   if (zzchar <= 0)        /* This means end of input. */
  484.     {
  485.       zzchar1 = 0;
  486.       zzchar = YYEOF;        /* Don't call YYLEX any more */
  487.  
  488. #if YYDEBUG != 0
  489.       if (zzdebug)
  490.     fprintf(stderr, "Now at end of input.\n");
  491. #endif
  492.     }
  493.   else
  494.     {
  495.       zzchar1 = YYTRANSLATE(zzchar);
  496.  
  497. #if YYDEBUG != 0
  498.       if (zzdebug)
  499.     fprintf(stderr, "Next token is %d (%s)\n", zzchar, zztname[zzchar1]);
  500. #endif
  501.     }
  502.  
  503.   zzn += zzchar1;
  504.   if (zzn < 0 || zzn > YYLAST || zzcheck[zzn] != zzchar1)
  505.     goto zzdefault;
  506.  
  507.   zzn = zztable[zzn];
  508.  
  509.   /* zzn is what to do for this token type in this state.
  510.      Negative => reduce, -zzn is rule number.
  511.      Positive => shift, zzn is new state.
  512.        New state is final state => don't bother to shift,
  513.        just return success.
  514.      0, or most negative number => error.  */
  515.  
  516.   if (zzn < 0)
  517.     {
  518.       if (zzn == YYFLAG)
  519.     goto zzerrlab;
  520.       zzn = -zzn;
  521.       goto zzreduce;
  522.     }
  523.   else if (zzn == 0)
  524.     goto zzerrlab;
  525.  
  526.   if (zzn == YYFINAL)
  527.     YYACCEPT;
  528.  
  529.   /* Shift the lookahead token.  */
  530.  
  531. #if YYDEBUG != 0
  532.   if (zzdebug)
  533.     fprintf(stderr, "Shifting token %d (%s), ", zzchar, zztname[zzchar1]);
  534. #endif
  535.  
  536.   /* Discard the token being shifted unless it is eof.  */
  537.   if (zzchar != YYEOF)
  538.     zzchar = YYEMPTY;
  539.  
  540.   *++zzvsp = zzlval;
  541. #ifdef YYLSP_NEEDED
  542.   *++zzlsp = zzlloc;
  543. #endif
  544.  
  545.   /* count tokens shifted since error; after three, turn off error status.  */
  546.   if (zzerrstatus) zzerrstatus--;
  547.  
  548.   zzstate = zzn;
  549.   goto zznewstate;
  550.  
  551. /* Do the default action for the current state.  */
  552. zzdefault:
  553.  
  554.   zzn = zzdefact[zzstate];
  555.   if (zzn == 0)
  556.     goto zzerrlab;
  557.  
  558. /* Do a reduction.  zzn is the number of a rule to reduce with.  */
  559. zzreduce:
  560.   zzlen = zzr2[zzn];
  561.   zzval = zzvsp[1-zzlen]; /* implement default value of the action */
  562.  
  563. #if YYDEBUG != 0
  564.   if (zzdebug)
  565.     {
  566.       int i;
  567.  
  568.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  569.            zzn, zzrline[zzn]);
  570.  
  571.       /* Print the symboles being reduced, and their result.  */
  572.       for (i = zzprhs[zzn]; zzrhs[i] > 0; i++)
  573.     fprintf (stderr, "%s ", zztname[zzrhs[i]]);
  574.       fprintf (stderr, " -> %s\n", zztname[zzr1[zzn]]);
  575.     }
  576. #endif
  577.  
  578.  
  579.   switch (zzn) {
  580.  
  581. case 1:
  582. #line 62 "posixtm.y"
  583. {
  584.              if (zzvsp[-5] >= 1 && zzvsp[-5] <= 12)
  585.            t.tm_mon = zzvsp[-5] - 1;
  586.          else {
  587.            YYABORT;
  588.          }
  589.          if (zzvsp[-4] >= 1 && zzvsp[-4] <= 31)
  590.            t.tm_mday = zzvsp[-4];
  591.          else {
  592.            YYABORT;
  593.          }
  594.          if (zzvsp[-3] >= 0 && zzvsp[-3] <= 23)
  595.            t.tm_hour = zzvsp[-3];
  596.          else {
  597.            YYABORT;
  598.          }
  599.          if (zzvsp[-2] >= 0 && zzvsp[-2] <= 59)
  600.            t.tm_min = zzvsp[-2];
  601.          else {
  602.            YYABORT;
  603.          }
  604.            ;
  605.     break;}
  606. case 2:
  607. #line 85 "posixtm.y"
  608. {
  609.                    t.tm_year = zzvsp[0];
  610.            /* Deduce the century based on the year.
  611.               See POSIX.2 section 4.63.3.  */
  612.            if (zzvsp[0] <= 68)
  613.              t.tm_year += 100;
  614.          ;
  615.     break;}
  616. case 3:
  617. #line 92 "posixtm.y"
  618. {
  619.                             t.tm_year = zzvsp[-1] * 100 + zzvsp[0];
  620.                 if (t.tm_year < 1900) {
  621.                   YYABORT;
  622.                 } else
  623.                   t.tm_year -= 1900;
  624.               ;
  625.     break;}
  626. case 4:
  627. #line 99 "posixtm.y"
  628. {
  629.                     time_t now;
  630.             struct tm *tmp;
  631.  
  632.                     /* Use current year.  */
  633.                     time (&now);
  634.             tmp = localtime (&now);
  635.             t.tm_year = tmp->tm_year;
  636.           ;
  637.     break;}
  638. case 5:
  639. #line 110 "posixtm.y"
  640. {
  641.                         t.tm_sec = 0;
  642.               ;
  643.     break;}
  644. case 6:
  645. #line 113 "posixtm.y"
  646. {
  647.                       if (zzvsp[0] >= 0 && zzvsp[0] <= 61)
  648.                 t.tm_sec = zzvsp[0];
  649.               else {
  650.                 YYABORT;
  651.               }
  652.             ;
  653.     break;}
  654. case 7:
  655. #line 122 "posixtm.y"
  656. {
  657.                           zzval = zzvsp[-1] * 10 + zzvsp[0];
  658.             ;
  659.     break;}
  660. }
  661.    /* the action file gets copied in in place of this dollarsign */
  662. #line 423 "bison.simple"
  663.  
  664.   zzvsp -= zzlen;
  665.   zzssp -= zzlen;
  666. #ifdef YYLSP_NEEDED
  667.   zzlsp -= zzlen;
  668. #endif
  669.  
  670. #if YYDEBUG != 0
  671.   if (zzdebug)
  672.     {
  673.       short *ssp1 = zzss - 1;
  674.       fprintf (stderr, "state stack now");
  675.       while (ssp1 != zzssp)
  676.     fprintf (stderr, " %d", *++ssp1);
  677.       fprintf (stderr, "\n");
  678.     }
  679. #endif
  680.  
  681.   *++zzvsp = zzval;
  682.  
  683. #ifdef YYLSP_NEEDED
  684.   zzlsp++;
  685.   if (zzlen == 0)
  686.     {
  687.       zzlsp->first_line = zzlloc.first_line;
  688.       zzlsp->first_column = zzlloc.first_column;
  689.       zzlsp->last_line = (zzlsp-1)->last_line;
  690.       zzlsp->last_column = (zzlsp-1)->last_column;
  691.       zzlsp->text = 0;
  692.     }
  693.   else
  694.     {
  695.       zzlsp->last_line = (zzlsp+zzlen-1)->last_line;
  696.       zzlsp->last_column = (zzlsp+zzlen-1)->last_column;
  697.     }
  698. #endif
  699.  
  700.   /* Now "shift" the result of the reduction.
  701.      Determine what state that goes to,
  702.      based on the state we popped back to
  703.      and the rule number reduced by.  */
  704.  
  705.   zzn = zzr1[zzn];
  706.  
  707.   zzstate = zzpgoto[zzn - YYNTBASE] + *zzssp;
  708.   if (zzstate >= 0 && zzstate <= YYLAST && zzcheck[zzstate] == *zzssp)
  709.     zzstate = zztable[zzstate];
  710.   else
  711.     zzstate = zzdefgoto[zzn - YYNTBASE];
  712.  
  713.   goto zznewstate;
  714.  
  715. zzerrlab:   /* here on detecting error */
  716.  
  717.   if (! zzerrstatus)
  718.     /* If not already recovering from an error, report this error.  */
  719.     {
  720.       ++zznerrs;
  721.  
  722. #ifdef YYERROR_VERBOSE
  723.       zzn = zzpact[zzstate];
  724.  
  725.       if (zzn > YYFLAG && zzn < YYLAST)
  726.     {
  727.       int size = 0;
  728.       char *msg;
  729.       int x, count;
  730.  
  731.       count = 0;
  732.       for (x = 0; x < (sizeof(zztname) / sizeof(char *)); x++)
  733.         if (zzcheck[x + zzn] == x)
  734.           size += strlen(zztname[x]) + 15, count++;
  735.       msg = (char *) xmalloc(size + 15);
  736.       strcpy(msg, "parse error");
  737.  
  738.       if (count < 5)
  739.         {
  740.           count = 0;
  741.           for (x = 0; x < (sizeof(zztname) / sizeof(char *)); x++)
  742.         if (zzcheck[x + zzn] == x)
  743.           {
  744.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  745.             strcat(msg, zztname[x]);
  746.             strcat(msg, "'");
  747.             count++;
  748.           }
  749.         }
  750.       zzerror(msg);
  751.       free(msg);
  752.     }
  753.       else
  754. #endif /* YYERROR_VERBOSE */
  755.     zzerror("parse error");
  756.     }
  757.  
  758. zzerrlab1:   /* here on error raised explicitly by an action */
  759.  
  760.   if (zzerrstatus == 3)
  761.     {
  762.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  763.  
  764.       /* return failure if at end of input */
  765.       if (zzchar == YYEOF)
  766.     YYABORT;
  767.  
  768. #if YYDEBUG != 0
  769.       if (zzdebug)
  770.     fprintf(stderr, "Discarding token %d (%s).\n", zzchar, zztname[zzchar1]);
  771. #endif
  772.  
  773.       zzchar = YYEMPTY;
  774.     }
  775.  
  776.   /* Else will try to reuse lookahead token
  777.      after shifting the error token.  */
  778.  
  779.   zzerrstatus = 3;        /* Each real token shifted decrements this */
  780.  
  781.   goto zzerrhandle;
  782.  
  783. zzerrdefault:  /* current state does not do anything special for the error token. */
  784.  
  785. #if 0
  786.   /* This is wrong; only states that explicitly want error tokens
  787.      should shift them.  */
  788.   zzn = zzdefact[zzstate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  789.   if (zzn) goto zzdefault;
  790. #endif
  791.  
  792. zzerrpop:   /* pop the current state because it cannot handle the error token */
  793.  
  794.   if (zzssp == zzss) YYABORT;
  795.   zzvsp--;
  796.   zzstate = *--zzssp;
  797. #ifdef YYLSP_NEEDED
  798.   zzlsp--;
  799. #endif
  800.  
  801. #if YYDEBUG != 0
  802.   if (zzdebug)
  803.     {
  804.       short *ssp1 = zzss - 1;
  805.       fprintf (stderr, "Error: state stack now");
  806.       while (ssp1 != zzssp)
  807.     fprintf (stderr, " %d", *++ssp1);
  808.       fprintf (stderr, "\n");
  809.     }
  810. #endif
  811.  
  812. zzerrhandle:
  813.  
  814.   zzn = zzpact[zzstate];
  815.   if (zzn == YYFLAG)
  816.     goto zzerrdefault;
  817.  
  818.   zzn += YYTERROR;
  819.   if (zzn < 0 || zzn > YYLAST || zzcheck[zzn] != YYTERROR)
  820.     goto zzerrdefault;
  821.  
  822.   zzn = zztable[zzn];
  823.   if (zzn < 0)
  824.     {
  825.       if (zzn == YYFLAG)
  826.     goto zzerrpop;
  827.       zzn = -zzn;
  828.       goto zzreduce;
  829.     }
  830.   else if (zzn == 0)
  831.     goto zzerrpop;
  832.  
  833.   if (zzn == YYFINAL)
  834.     YYACCEPT;
  835.  
  836. #if YYDEBUG != 0
  837.   if (zzdebug)
  838.     fprintf(stderr, "Shifting error token, ");
  839. #endif
  840.  
  841.   *++zzvsp = zzlval;
  842. #ifdef YYLSP_NEEDED
  843.   *++zzlsp = zzlloc;
  844. #endif
  845.  
  846.   zzstate = zzn;
  847.   goto zznewstate;
  848. }
  849. #line 126 "posixtm.y"
  850.  
  851. static int
  852. zzlex ()
  853. {
  854.   char ch = *curpos++;
  855.  
  856.   if (ch >= '0' && ch <= '9')
  857.     {
  858.       zzlval = ch - '0';
  859.       return DIGIT;
  860.     }
  861.   else if (ch == '.' || ch == 0)
  862.     return ch;
  863.   else
  864.     return '?';            /* Cause an error.  */
  865. }
  866.  
  867. static int
  868. zzerror ()
  869. {
  870.   return 0;
  871. }
  872.  
  873. /* Parse a POSIX-style date and return it, or (time_t)-1 for an error.  */
  874.  
  875. time_t
  876. posixtime (s)
  877.      char *s;
  878. {
  879.   curpos = s;
  880.   /* Let mktime decide whether it is daylight savings time.  */
  881.   t.tm_isdst = -1;
  882.   if (zzparse ())
  883.     return (time_t)-1;
  884.   else
  885.     return mktime (&t);
  886. }
  887.  
  888. /* Parse a POSIX-style date and return it, or NULL for an error.  */
  889.  
  890. struct tm *
  891. posixtm (s)
  892.      char *s;
  893. {
  894.   if (posixtime (s) == -1)
  895.     return NULL;
  896.   return &t;
  897. }
  898.